#ifndef MEMORY_CACHE_H
#define MEMORY_CACHE_H

#include "lru_cache.h"
#include <functional>
#include <iostream>
#include <sstream>

// 内存缓存层（L1缓存）
// 继承自LRU缓存，提供高速的内存访问
template<typename KeyType, typename ValueType>
class MemoryCache : public LRUCache<KeyType, ValueType> {
private:
    // 淘汰回调函数类型
    using EvictionCallback = std::function<void(const KeyType&, const ValueType&)>;
    EvictionCallback eviction_callback_;

    // 序列化函数类型（用于估算内存占用）
    using SizeEstimator = std::function<size_t(const ValueType&)>;
    SizeEstimator size_estimator_;

    size_t current_memory_usage_;                                  // 当前内存使用量（字节）
    size_t max_memory_limit_;                                      // 最大内存限制（字节）

protected:
    // 重写淘汰时的钩子函数
    virtual void onEvict(const KeyType& key, const ValueType& value) override {
        if (eviction_callback_) {
            eviction_callback_(key, value);
        }

        // 更新内存使用量
        if (size_estimator_) {
            current_memory_usage_ -= size_estimator_(value);
        }
    }

public:
    // 构造函数
    MemoryCache(size_t capacity, size_t max_memory_mb = 100)
        : LRUCache<KeyType, ValueType>(capacity)
        , current_memory_usage_(0)
        , max_memory_limit_(max_memory_mb * 1024 * 1024) {

        // 设置默认的大小估算器
        size_estimator_ = [](const ValueType& value) -> size_t {
            // 这是一个简单的估算，实际使用时应根据ValueType提供更准确的估算
            return sizeof(ValueType);
        };
    }

    // 设置淘汰回调函数
    void setEvictionCallback(const EvictionCallback& callback) {
        eviction_callback_ = callback;
    }

    // 设置大小估算函数
    void setSizeEstimator(const SizeEstimator& estimator) {
        size_estimator_ = estimator;
    }

    // 重写put函数以检查内存限制
    virtual void put(const KeyType& key, const ValueType& value) override {
        size_t value_size = size_estimator_ ? size_estimator_(value) : sizeof(ValueType);

        // 检查内存限制
        if (current_memory_usage_ + value_size > max_memory_limit_) {
            // 需要淘汰一些条目以腾出空间
            while (current_memory_usage_ + value_size > max_memory_limit_ && this->size() > 0) {
                this->evict();
            }
        }

        // 调用父类的put方法
        LRUCache<KeyType, ValueType>::put(key, value);
        current_memory_usage_ += value_size;
    }

    // 获取当前内存使用量
    size_t getCurrentMemoryUsage() const {
        return current_memory_usage_;
    }

    // 获取最大内存限制
    size_t getMaxMemoryLimit() const {
        return max_memory_limit_;
    }

    // 设置最大内存限制
    void setMaxMemoryLimit(size_t max_memory_mb) {
        max_memory_limit_ = max_memory_mb * 1024 * 1024;
    }

    // 获取内存使用率
    double getMemoryUsageRatio() const {
        if (max_memory_limit_ == 0) return 0.0;
        return static_cast<double>(current_memory_usage_) / max_memory_limit_;
    }

    // 打印缓存统计信息
    void printStatistics() const {
        std::cout << "\n=== 内存缓存（L1）统计信息 ===" << std::endl;
        std::cout << "缓存容量: " << this->capacity() << " 条" << std::endl;
        std::cout << "当前大小: " << this->size() << " 条" << std::endl;
        std::cout << "内存使用: " << current_memory_usage_ / (1024.0 * 1024.0)
                  << " MB / " << max_memory_limit_ / (1024.0 * 1024.0) << " MB" << std::endl;
        std::cout << "内存使用率: " << (getMemoryUsageRatio() * 100) << "%" << std::endl;
        std::cout << "命中次数: " << this->getHitCount() << std::endl;
        std::cout << "未命中次数: " << this->getMissCount() << std::endl;
        std::cout << "命中率: " << (this->getHitRate() * 100) << "%" << std::endl;
        std::cout << "==============================\n" << std::endl;
    }
};

#endif // MEMORY_CACHE_H